# -*- coding: utf-8 -*-
# This file has been generated, if you wish to
# modify it in a permanent way, please refer
# to the script file : gen/generator_python.rb

from api import *
from random import *

# Fonction appelée au début de la partie.
def partie_init():
    pass # Place ton code ici

# Fonction appelée à chaque tour.
def jouer_tour():
    
    #Première partie au cas où la neutralisation, capture ou protection n'a pas été mise en place faut de points d'action.
    #Elle ressemble donc exactement à la fin de ce code.
    if portail_joueur(position_agent(moi()))!=-2:
        #Si on peut, on neutralise.
        neutraliser()
        
        #Si on peut, on capture.
        capturer()
        
        #Oui cette condition est inutile mais mon code marche comme ça je ne veux plus y toucher :)
        if 1==1:
            
            #Dans ll seront stockés les liens potentiellement construisible.
            ll=[]
            for i in liste_portails():
                
                #Si le portail i m'appartient et si aucun lien n'est là pour en empêcher la création alors j'ajoute i dans ll.
                if portail_joueur(i)==moi() and liens_bloquants(i,position_agent(moi()))==[]:
                    ll=ll+[i]
            
            #L'idée ici va consister à choisir au maximum deux liens parmi ceux possibles qui vont maximiser l'aire crée.
            if len(ll)>=1:i1=ll[0]  
            if len(ll)>=2:j1=ll[1]
            if len(ll)>=2:
                val=0
                for i in ll:
                    for j in ll:
                        v=score_triangle(i,j,position_agent(moi()))
                        if lien_existe(i,j) and v>val:
                            val=v
                            i1=i
                            j1=j
            
            #Une fois l'aire maximale crée (dans le but de tenter de former une suite de triangle avec la même base) on peut ajouter tous les liens possibles qu'on veut, peu importe l'ordre.
            for i in liste_portails():
                if portail_joueur(i)==moi():
                    lier(i)
                    
            #Enfin on active les boucliers.
            ajouter_bouclier()
            ajouter_bouclier()
            ajouter_bouclier()
            ajouter_bouclier()
            ajouter_bouclier()
            ajouter_bouclier()
        
    #Pour pouvoir sortir du while.
    alpha=10
            
    #Tant qu'il nous reste des points de mouvement ou points d'action convertibles en points de mouvement on cherche le portail optimal vers lequel se rapprocher et on s'y rapproche au maximum.
    #Si on atteint un portail à temps on peut commencer à le neutraliser, capturer et protéger, et ensuite on passe au suivant.
    while (points_deplacement()>0 or points_action()>=6) and alpha>0:
        alpha-=1
        (x,y)=position_agent(moi())
        lp=liste_portails ()
        p=(lp[0])
        vmin=10000
        
        #On parcourt donc la liste des portails pour décider vers lequel on va se diriger.
        for i in lp:
            pj=portail_joueur(i)
            
            #Seuls les portails neutres, ou adversaires mais ayant au moins un lien nous intéressent.
            #Le portail ne nous intéresse pas si l'adversaire y est déjà.
            if (pj==-1 or (pj==adversaire() and len(liens_incidents_portail(i))>=1)) and (i!=position_agent(adversaire())):
                x1,y1=i
                
                #Même chose donc qu'au début pour trouver s'il y a deux liens optimaux et donc les créer en priorité avant les autres
                #Je ne crée pas les liens tout de suite mais je regarde si le portail pourrait créer un bon triangle
                ll=[]
                val=0 
                for j in liste_portails():
                    if portail_joueur(j)==moi() and liens_bloquants(j,i)==[]:
                        ll=ll+[j]
                if len(ll)>=1:i1=ll[0]
                if len(ll)>=2:j1=ll[1]
                if len(ll)>=2:
                    for k in ll:
                        for j in ll:
                            v=score_triangle(k,j,i)
                            if lien_existe(k,j) and v>val:
                                val=v
                                i1=k
                                j1=j
                ll=liste_liens()
                
                #Partie de code n'ayant plus d'utilité
                #advance=4
                #if tour_actuel()<40:advance=4
                #if tour_actuel()<20:advance=4
                #if tour_actuel()<10:advance=4
                
                #boo2 vaut False si on est amené à traverser un lien adverse pour rejoindre le portail.
                boo2=True
                for j in ll:
                    if intersection_segments((x,y),i,j.extr1,j.extr2) and j.joueur_l==adversaire():boo2=False
                 
                #boo3 vaut True si il existe au moins un lien créable à partir du portail i.
                for k in liste_portails():
                    booTmp=True
                    for j in ll:    
                        if intersection_segments(k,i,j.extr1,j.extr2):booTmp=False
                    if booTmp:boo3=True
                
                #advance et v prennent pour valeur la distance hamiltonienne entre i et la position actuelle.
                advance=abs(x1-x)+abs(y1-y)    
                v=abs(x1-x)+abs(y1-y)
                
                #Si la distance au portail est trop grande on rajoute un malus à v pour n'aller à ce portail qu'en cas d'extrême besoin.
                if v>=18:v=100
                
                #Information : je cherche à trouver une valeur v d'un portail la plus petite possible.
                
                #Caractérise l'importance d'aller neutraliser des sommets de haut degré de l'adversaire.
                v-=len(liens_incidents_portail(i))**2
                
                #Prise en compte du triangle optimal à créer, le fait de diviser par la distance au portail montre l'importance que j'accorde à aller chercher le sommet d'un nouveau triangle pas très loin mais qui dessine une aire assez élevée.
                v-=3*val//advance
                
                #Ajout d'une petite importance d'aller chercher à neutraliser l'adversaire.
                if pj==adversaire():v-=4
                
                #Si i se trouve dans un champ, on rajoute un malus à v pour n'aller à ce portail qu'en cas d'extrême besoin.
                cc=case_champs(i)
                if pj==-1 and cc!=[]:v+=200
                
                #Prise en compte de boo2 et boo3 comme expliqué précédemment.
                if boo2:v-=10
                if boo3:v-=50
                
                if v<vmin:
                    vmin=v
                    p=i
                    
        x1,y1=p
        
        #Partie déplacement. On se rapproche au plus près du portail choisi, quitte à utiliser des turbos.
        boo=True
        while points_deplacement()>0 and boo:
            (x,y)=position_agent(moi())
            if x1>x:deplacer((x+1,y))
            elif x1<x:deplacer((x-1,y))
            elif y1>y:deplacer((x,y+1))
            elif y1<y:deplacer((x,y-1))
            else:boo=False
            if points_deplacement()==0:utiliser_turbo()
             
        #Partie similaire au début du code.
        if portail_joueur(position_agent(moi()))!=-2:
            neutraliser()
            capturer()
            if 1==1:
                ll=[]
                for i in liste_portails():
                    if portail_joueur(i)==moi() and liens_bloquants(i,position_agent(moi()))==[]:
                        ll=ll+[i]
                
                if len(ll)>=1:i1=ll[0]  
                if len(ll)>=2:j1=ll[1]
                if len(ll)>=2:
                    val=0
                    for i in ll:
                        for j in ll:
                            v=score_triangle(i,j,position_agent(moi()))
                            if lien_existe(i,j) and v>val:
                                val=v
                                i1=i
                                j1=j
                for i in liste_portails():
                    if portail_joueur(i)==moi():
                        lier(i)
                ajouter_bouclier()
                ajouter_bouclier()
                ajouter_bouclier()
                ajouter_bouclier()
                ajouter_bouclier()
                ajouter_bouclier()

# Fonction appelée à la fin de la partie.
def partie_fin():
    pass # Place ton code ici


